const express = require('express');
const cors = require('cors');
const mysql = require('mysql2');
const jwt = require('jsonwebtoken');
const app = express();

// 中间件配置
app.use(cors({
    origin: 'http://localhost:8080', 
    methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'], 
    allowedHeaders: ['Content-Type', 'Authorization'],
}));
app.use(express.json());

// ================================ 数据库配置 ================================
const db = mysql.createPool({
    host: 'localhost',
    port: 3306,
    user: 'root',
    password: 'a77803901a',
    database: 'FYH', 
    connectionLimit: 10,
    waitForConnections: true,
    queueLimit: 0
});

// ================================ 中间件 ================================
function verifyToken(req, res, next) {
    const authHeader = req.headers.authorization;
    if (!authHeader) {
        return res.status(401).json({ message: '未提供 Token' });
    }

    const token = authHeader.split(' ')[1];
    jwt.verify(token, 'key', (err, decoded) => {
        if (err) {
            return res.status(403).json({ message: 'Token 无效或已过期' });
        }
        req.user = decoded;
        next();
    });
}

function verifyAdmin(req, res, next) {
    if (req.user.role !== '管理员') {
        return res.status(403).json({ message: '无权限执行此操作' });
    }
    next();
}

// ================================ 用户管理 ================================

app.post('/users', verifyToken, verifyAdmin, (req, res) => {
    const { name, password, role_id, phone, owner_id, unit_id, floor, room_count } = req.body;

    // 验证必填字段
    if (!name || !password || !role_id || !owner_id) {
        return res.status(400).json({ message: '姓名、密码、角色和 owner_id 不能为空' });
    }

    if (role_id === 2) {
        if (floor === undefined || room_count === undefined) {
            return res.status(400).json({ message: '业主用户需要提供楼层和房间数' });
        }
    }

    // 检查 owner_id 是否唯一
    const checkOwnerIdSql = 'SELECT id FROM users WHERE owner_id = ?';
    db.query(checkOwnerIdSql, [owner_id], (err, results) => {
        if (err) {
            console.error('数据库错误:', err);
            return res.status(500).json({ message: '服务器错误' });
        }

        if (results.length > 0) {
            return res.status(400).json({ message: 'owner_id 已存在，请选择另一个 ID' });
        }

        // 插入新用户
        const insertSql = `
            INSERT INTO users (name, password, role_id, phone, owner_id, unit_id, floor, room_count) 
            VALUES (?, ?, ?, ?, ?, ?, ?, ?)
        `;
        db.query(insertSql, [
            name,
            password,
            role_id,
            phone || null,
            owner_id,
            unit_id || null,
            role_id === 2 ? floor : 0, 
            role_id === 2 ? room_count : 0 
        ], (err) => {
            if (err) {
                console.error('数据库错误:', err);
                return res.status(500).json({ message: '服务器错误' });
            }
            res.status(201).json({ message: '用户添加成功' });
        });
    });
});

// 用户登录
app.post('/login', (req, res) => {
    const { owner_id, password } = req.body;  

    if (!owner_id || !password) {
        return res.status(400).json({ message: '用户名和密码不能为空' });
    }

    const sql = `
        SELECT u.id, u.owner_id, u.name, u.phone, u.password, r.role_name 
        FROM users u 
        JOIN roles r ON u.role_id = r.id 
        WHERE u.owner_id = ?
    `;

    db.query(sql, [owner_id], (err, result) => {
        if (err) {
            console.log('数据库查询错误:', err);
            return res.status(500).json({ message: '服务器错误' });
        }

        if (result.length === 0) {
            console.log('用户不存在');
            return res.status(404).json({ message: '用户不存在' });
        }

        const user = result[0];

        const match = password === user.password;
        if (!match) {
            return res.status(401).json({ message: '密码错误' });
        }

        const token = jwt.sign(
            { userId: user.id, owner_id: user.owner_id, role: user.role_name, phone: user.phone },
            'key', { expiresIn: '1h' }
        );

        res.status(200).json({
            message: '登录成功',
            token,
            user: { userId: user.id, owner_id: user.owner_id, role: user.role_name, phone: user.phone },
        });
    });
});

// 获取所有用户列表
app.get('/users', verifyToken, verifyAdmin, (req, res) => {
    const sql = `
        SELECT u.id, u.owner_id, u.name, u.role_id, r.role_name, u.phone, u.unit_id, u.floor, u.room_count 
        FROM users u 
        JOIN roles r ON u.role_id = r.id
    `;

    db.query(sql, (err, result) => {
        if (err) {
            console.log('服务器查询失败:', err);
            return res.status(500).json({ message: '服务器错误' });
        }
        res.status(200).json({ message: '获取用户列表成功', data: result });
    });
});

// 获取当前用户信息
app.get('/users/me', verifyToken, (req, res) => {
    const userId = req.user.userId;
    const sql = `
        SELECT u.id, u.owner_id, u.name, u.phone, r.role_name 
        FROM users u 
        JOIN roles r ON u.role_id = r.id 
        WHERE u.id = ?
    `;

    db.query(sql, [userId], (err, result) => {
        if (err) {
            console.log('数据库查询失败:', err);
            return res.status(500).json({ message: '服务器错误' });
        }

        if (result.length === 0) {
            return res.status(404).json({ message: '用户不存在' });
        }

        const user = result[0];
        res.status(200).json({
            message: '获取用户信息成功',
            data: { user_id: user.id, username: user.owner_id, name: user.name, role: user.role_name, phone: user.phone },
        });
    });
});

// 删除用户
app.delete('/users/:id', verifyToken, verifyAdmin, (req, res) => {
    const userId = req.params.id;
    const sql = 'DELETE FROM users WHERE id = ?';

    db.query(sql, [userId], (err, result) => {
        if (err) {
            console.log('删除失败:', err);
            return res.status(500).json({ message: '服务器错误' });
        }
        if (result.affectedRows === 0) {
            return res.status(404).json({ message: '用户不存在' });
        }
        res.status(200).json({ message: '用户删除成功' });
    });
});

// 更新用户信息
app.patch('/users/:id', verifyToken, verifyAdmin, (req, res) => {
    const userId = parseInt(req.params.id, 10);
    const { name, phone, role_id, owner_id, floor, room_count, unit_id } = req.body;


    // 只有管理员可以修改用户信息
    if (req.user.userId !== userId && req.user.role !== '管理员') {
        return res.status(403).json({ message: '您无权修改此用户的资料' });
    }

    // 验证至少有一个字段需要更新
    if (!name && !phone && !role_id && !owner_id && floor === undefined && room_count === undefined && unit_id === undefined) {
        return res.status(400).json({ message: '至少提供一个需要更新的字段' });
    }

    if (role_id === 2) {
        if (floor === undefined || room_count === undefined) {
            return res.status(400).json({ message: '业主用户需要提供楼层和房间数' });
        }
    }

    // 检查 owner_id 是否唯一（如果更新了 owner_id）
    if (owner_id) {
        const checkOwnerIdSql = 'SELECT id FROM users WHERE owner_id = ? AND id != ?';
        db.query(checkOwnerIdSql, [owner_id, userId], (err, results) => {
            if (err) {
                console.error('数据库错误:', err);
                return res.status(500).json({ message: '服务器错误' });
            }

            if (results.length > 0) {
                return res.status(400).json({ message: 'owner_id 已存在，请选择另一个 ID' });
            }

            // 构建动态更新字段
            let fields = [];
            let values = [];

            if (name) {
                fields.push('name = ?');
                values.push(name);
            }
            if (phone) {
                fields.push('phone = ?');
                values.push(phone);
            }
            if (role_id) {
                fields.push('role_id = ?');
                values.push(role_id);
            }
            if (owner_id) {
                fields.push('owner_id = ?');
                values.push(owner_id);
            }
            if (unit_id !== undefined) {
                fields.push('unit_id = ?');
                values.push(unit_id);
            }
            if (floor !== undefined) {
                fields.push('floor = ?');
                values.push(role_id === 2 ? floor : 0); // 非业主用户设置 floor 为 0
            }
            if (room_count !== undefined) {
                fields.push('room_count = ?');
                values.push(role_id === 2 ? room_count : 0); // 非业主用户设置 room_count 为 0
            }

            if (fields.length === 0) {
                return res.status(400).json({ message: '至少提供一个需要更新的字段' });
            }

            const updateSql = `UPDATE users SET ${fields.join(', ')} WHERE id = ?`;
            values.push(userId);


            db.query(updateSql, values, (err, result) => {
                if (err) {
                    console.log('更新失败:', err);
                    return res.status(500).json({ message: '服务器错误' });
                }

                if (result.affectedRows === 0) {
                    return res.status(404).json({ message: '用户不存在' });
                }
                res.status(200).json({ message: '用户资料更新成功' });
            });
        });
    } else {
        let fields = [];
        let values = [];

        if (name) {
            fields.push('name = ?');
            values.push(name);
        }
        if (phone) {
            fields.push('phone = ?');
            values.push(phone);
        }
        if (role_id) {
            fields.push('role_id = ?');
            values.push(role_id);
        }
        if (unit_id !== undefined) {
            fields.push('unit_id = ?');
            values.push(unit_id);
        }
        if (floor !== undefined) {
            fields.push('floor = ?');
            values.push(role_id === 2 ? floor : 0); // 非业主用户设置 floor 为 0
        }
        if (room_count !== undefined) {
            fields.push('room_count = ?');
            values.push(role_id === 2 ? room_count : 0); // 非业主用户设置 room_count 为 0
        }

        if (fields.length === 0) {
            return res.status(400).json({ message: '至少提供一个需要更新的字段' });
        }

        const updateSql = `UPDATE users SET ${fields.join(', ')} WHERE id = ?`;
        values.push(userId);


        db.query(updateSql, values, (err, result) => {
            if (err) {
                console.log('更新失败:', err);
                return res.status(500).json({ message: '服务器错误' });
            }

            if (result.affectedRows === 0) {
                return res.status(404).json({ message: '用户不存在' });
            }
            res.status(200).json({ message: '用户资料更新成功' });
        });
    }
});

// ================================ 物业管理 ================================

app.get('/buildings', verifyToken, (req, res) => {
    const sql = 'SELECT * FROM buildings';

    db.query(sql, (err, result) => {
        if (err) {
            console.log('获取建筑物失败:', err);
            return res.status(500).json({ message: '服务器错误' });
        }
        res.status(200).json({ message: '获取建筑物列表成功', data: result });
    });
});

app.post('/buildings', verifyToken, verifyAdmin, (req, res) => {
    const { name, address } = req.body;

    if (!name || !address) {
        return res.status(400).json({ message: '建筑物名称和地址不能为空' });
    }

    const sql = 'INSERT INTO buildings (name, address) VALUES (?, ?)';
    db.query(sql, [name, address], (err) => {
        if (err) {
            console.error('数据库错误:', err);
            return res.status(500).json({ message: '服务器错误' });
        }
        res.status(201).json({ message: '建筑物添加成功' });
    });
});

app.put('/buildings/:id', verifyToken, verifyAdmin, (req, res) => {
    const { id } = req.params;
    const { name, address } = req.body;

    if (!name || !address) {
        return res.status(400).json({ message: '建筑物名称和地址不能为空' });
    }

    const sql = 'UPDATE buildings SET name = ?, address = ? WHERE id = ?';
    db.query(sql, [name, address, id], (err, result) => {
        if (err) {
            console.log('更新失败:', err);
            return res.status(500).json({ message: '服务器错误' });
        }

        if (result.affectedRows === 0) {
            return res.status(404).json({ message: '建筑物不存在' });
        }
        res.status(200).json({ message: '建筑物信息更新成功' });
    });
});

app.delete('/buildings/:id', verifyToken, verifyAdmin, (req, res) => {
    const buildingId = req.params.id;
    const sql = 'DELETE FROM buildings WHERE id = ?';

    db.query(sql, [buildingId], (err, result) => {
        if (err) {
            console.log('删除失败:', err);
            return res.status(500).json({ message: '服务器错误' });
        }
        if (result.affectedRows === 0) {
            return res.status(404).json({ message: '建筑物不存在' });
        }
        res.status(200).json({ message: '建筑物删除成功' });
    });
});

// ================================ 单元管理 ================================

app.get('/units', verifyToken, (req, res) => {
    const sql = 'SELECT * FROM units';

    db.query(sql, (err, result) => {
        if (err) {
            console.log('获取单元信息失败:', err);
            return res.status(500).json({ message: '服务器错误' });
        }
        res.status(200).json({ message: '获取单元信息成功', data: result });
    });
});

app.post('/units', verifyToken, verifyAdmin, (req, res) => {
    const { unit_number, building_id } = req.body;

    if (!unit_number || !building_id) {
        return res.status(400).json({ message: '单元编号和建筑物ID不能为空' });
    }

    // 检查建筑物是否存在
    db.query('SELECT id FROM buildings WHERE id = ?', [building_id], (err, buildingsResult) => {
        if (err) {
            console.error('数据库错误:', err);
            return res.status(500).json({ message: '服务器错误' });
        }

        if (buildingsResult.length === 0) {
            return res.status(400).json({ message: '建筑物ID不存在' });
        }

        // 插入单元
        const insertSql = 'INSERT INTO units (unit_number, building_id) VALUES (?, ?)';
        db.query(insertSql, [unit_number, building_id], (err) => {
            if (err) {
                if (err.code === 'ER_DUP_ENTRY') {
                    return res.status(400).json({ message: '该建筑物中单元编号已存在' });
                }
                console.error('数据库错误:', err);
                return res.status(500).json({ message: '服务器错误' });
            }
            res.status(201).json({ message: '单元添加成功' });
        });
    });
});

app.put('/units/:id', verifyToken, verifyAdmin, (req, res) => {
    const { id } = req.params;
    const { unit_number, building_id } = req.body;


    // 输入验证
    if (!unit_number || !building_id) {
        return res.status(400).json({ message: '单元号和建筑物ID不能为空' });
    }

    // 检查建筑物是否存在
    db.query('SELECT id FROM buildings WHERE id = ?', [building_id], (err, buildingsResult) => {
        if (err) {
            console.error('数据库错误:', err);
            return res.status(500).json({ message: '服务器错误' });
        }

        if (buildingsResult.length === 0) {
            return res.status(400).json({ message: '建筑物ID不存在' });
        }

        // 更新单元
        db.query('UPDATE units SET unit_number = ?, building_id = ? WHERE id = ?', [unit_number, building_id, id], (err, updateResult) => {
            if (err) {
                console.error('更新失败:', err);
                return res.status(500).json({ message: '服务器错误' });
            }

            if (updateResult.affectedRows === 0) {
                return res.status(404).json({ message: '单元不存在' });
            }

            res.status(200).json({ message: '单元信息更新成功' });
        });
    });
});

app.delete('/units/:id', verifyToken, verifyAdmin, (req, res) => {
    const unitId = req.params.id;
    const sql = 'DELETE FROM units WHERE id = ?';

    db.query(sql, [unitId], (err, result) => {
        if (err) {
            console.log('删除失败:', err);
            return res.status(500).json({ message: '服务器错误' });
        }
        if (result.affectedRows === 0) {
            return res.status(404).json({ message: '单元不存在' });
        }
        res.status(200).json({ message: '单元删除成功' });
    });
});

// ================================ 公告管理 ================================

// 获取所有公告
app.get('/announcements', verifyToken, (req, res) => {
    const sql = 'SELECT id, title, content, date FROM announcements ORDER BY date DESC';

    db.query(sql, (err, result) => {
        if (err) {
            console.error('获取公告失败:', err);
            return res.status(500).json({ message: '服务器错误' });
        }

        res.status(200).json({ message: '获取公告成功', data: result });
    });
});

// 添加公告
app.post('/announcements', verifyToken, verifyAdmin, (req, res) => {
    const { title, content } = req.body;

    // 验证必填字段
    if (!title || !content) {
        return res.status(400).json({ message: '标题和内容不能为空' });
    }

    // 获取当前日期和时间
    const date = new Date();

    const sql = 'INSERT INTO announcements (title, content, date) VALUES (?, ?, ?)';
    db.query(sql, [title, content, date], (err, result) => {
        if (err) {
            console.error('添加公告失败:', err);
            return res.status(500).json({ message: '服务器错误' });
        }

        // 返回新创建的公告ID
        res.status(201).json({ message: '公告添加成功', data: { id: result.insertId, title, content, date } });
    });
});

// 更新公告
app.put('/announcements/:id', verifyToken, verifyAdmin, (req, res) => {
    const { id } = req.params;
    const { title, content } = req.body;

    // 验证必填字段
    if (!title || !content) {
        return res.status(400).json({ message: '标题和内容不能为空' });
    }

    const sql = 'UPDATE announcements SET title = ?, content = ? WHERE id = ?';
    db.query(sql, [title, content, id], (err, result) => {
        if (err) {
            console.error('更新公告失败:', err);
            return res.status(500).json({ message: '服务器错误' });
        }

        if (result.affectedRows === 0) {
            return res.status(404).json({ message: '公告不存在' });
        }

        res.status(200).json({ message: '公告更新成功' });
    });
});

// 删除公告
app.delete('/announcements/:id', verifyToken, verifyAdmin, (req, res) => {
    const announcementId = req.params.id;
    const sql = 'DELETE FROM announcements WHERE id = ?';

    db.query(sql, [announcementId], (err, result) => {
        if (err) {
            console.log('删除公告失败:', err);
            return res.status(500).json({ message: '服务器错误' });
        }
        if (result.affectedRows === 0) {
            return res.status(404).json({ message: '公告不存在' });
        }
        res.status(200).json({ message: '公告删除成功' });
    });
});

// ================================ 动态管理 ================================

// 获取所有动态
app.get('/activities', verifyToken, (req, res) => {
    const sql = 'SELECT id, title, description, date FROM activities ORDER BY date DESC';

    db.query(sql, (err, result) => {
        if (err) {
            console.error('获取动态失败:', err);
            return res.status(500).json({ message: '服务器错误' });
        }

        res.status(200).json({ message: '获取动态成功', data: result });
    });
});

// 添加动态
app.post('/activities', verifyToken, verifyAdmin, (req, res) => {
    const { title, description } = req.body;

    // 验证必填字段
    if (!title || !description) {
        return res.status(400).json({ message: '标题和描述不能为空' });
    }

    // 获取当前日期和时间
    const date = new Date();

    const sql = 'INSERT INTO activities (title, description, date) VALUES (?, ?, ?)';
    db.query(sql, [title, description, date], (err, result) => {
        if (err) {
            console.error('添加动态失败:', err);
            return res.status(500).json({ message: '服务器错误' });
        }

        // 返回新创建的动态ID
        res.status(201).json({ message: '动态添加成功', data: { id: result.insertId, title, description, date } });
    });
});

// 更新动态
app.put('/activities/:id', verifyToken, verifyAdmin, (req, res) => {
    const { id } = req.params;
    const { title, description } = req.body;

    // 验证必填字段
    if (!title || !description) {
        return res.status(400).json({ message: '标题和描述不能为空' });
    }

    const sql = 'UPDATE activities SET title = ?, description = ? WHERE id = ?';
    db.query(sql, [title, description, id], (err, result) => {
        if (err) {
            console.error('更新动态失败:', err);
            return res.status(500).json({ message: '服务器错误' });
        }

        if (result.affectedRows === 0) {
            return res.status(404).json({ message: '动态不存在' });
        }

        res.status(200).json({ message: '动态更新成功' });
    });
});

// 删除动态
app.delete('/activities/:id', verifyToken, verifyAdmin, (req, res) => {
    const activityId = req.params.id;
    const sql = 'DELETE FROM activities WHERE id = ?';

    db.query(sql, [activityId], (err, result) => {
        if (err) {
            console.log('删除动态失败:', err);
            return res.status(500).json({ message: '服务器错误' });
        }
        if (result.affectedRows === 0) {
            return res.status(404).json({ message: '动态不存在' });
        }
        res.status(200).json({ message: '动态删除成功' });
    });
});

// 获取房间状态
app.get('/rooms/status', verifyToken, (req, res) => {
    const sql = 'SELECT COUNT(*) AS total, SUM(CASE WHEN status = "空闲" THEN 1 ELSE 0 END) AS free FROM rooms';

    db.query(sql, (err, result) => {
        if (err) {
            console.error('获取房间状态失败:', err);
            return res.status(500).json({ message: '服务器错误' });
        }

        if (result.length === 0) {
            return res.status(404).json({ message: '未找到房间数据' });
        }

        res.status(200).json({
            message: '获取房间状态成功',
            data: {
                total: result[0].total,
                free: result[0].free,
            },
        });
    });
});

// 获取物业统计数据
app.get('/statistics', verifyToken, (req, res) => {
    const sql = `
        SELECT property_type, COUNT(*) AS count
        FROM buildings
        GROUP BY property_type
    `;

    db.query(sql, (err, result) => {
        if (err) {
            console.error('获取物业统计数据失败:', err);
            return res.status(500).json({ message: '服务器错误' });
        }

        const data = result.map(row => ({
            value: row.count,
            name: row.property_type,
        }));

        res.status(200).json({
            message: '获取物业统计数据成功',
            data,
        });
    });
});

// ================================ 启动服务器 ================================
const port = 3008;
app.listen(port, () => {
    console.log(`服务器正在运行 http://localhost:${port}`);
});
